/**
 * 
 */
package com.cssy.yd.logic.service.impl;

import java.util.Date;
import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSONArray;
import com.byd.acegiext.domain.User;
import com.cssy.yd.logic.dao.LogicSoDAO;
import com.cssy.yd.logic.dao.LogicSoItemDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezeDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezeItemDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezedealDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezedealItemBatchDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezedealItemDAO;
import com.cssy.yd.logic.entity.LogicSoDO;
import com.cssy.yd.logic.entity.LogicSoItemDO;
import com.cssy.yd.logic.entity.LogicSoWareItemBatchDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezeDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezedealDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezeItemDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezedealItemBatchDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezedealItemDO;
import com.cssy.yd.logic.entity.LogicWhAffDO;
import com.cssy.yd.logic.service.ILogicSoWarefreezedealService;
import com.cssy.yd.logic.service.ILogicWhAffStockService;
import com.cssy.yd.logic.util.MathUtil;
import com.cssy.yd.logic.util.logic.LogicSoBeanUtil;
import com.plat.exception.SyBaseException;
import com.plat.helper.SearchCondition;
import com.plat.helper.SearchConditions;
import com.plat.helper.SearchResult;
import com.plat.util.DateUtils;
import com.plat.util.GlobalResLoader;
import com.plat.util.IDCodeTypeUtil;
import com.plat.util.SessionUtil;
import com.yuendong.sy.po.code.SyCode;
import com.yuendong.sy.service.code.SyCodeType;
import com.yuendong.sy.service.code.impl.SyCodeService;

/**
 * @author huang.xuming [2013-8-2]
 *
 */
@Service("logicSoWarefreezedealService")
public class LogicSoWarefreezedealServiceImpl implements ILogicSoWarefreezedealService {
	private static final Logger logger = Logger.getLogger(LogicSoWarefreezedealServiceImpl.class);
	
	@Resource(name = "logicSoWarefreezedealDAO")
	LogicSoWarefreezedealDAO logicSoWarefreezedealDAO;
	
	@Resource(name = "logicSoWarefreezedealItemDAO")
	LogicSoWarefreezedealItemDAO logicSoWarefreezedealItemDAO;
	
	@Resource(name = "logicSoWarefreezeDAO")
	LogicSoWarefreezeDAO logicSoWarefreezeDAO;
	
	@Resource(name = "logicSoWarefreezeItemDAO")
	LogicSoWarefreezeItemDAO logicSoWarefreezeItemDAO;
	
	@Resource(name = "logicSoDAO")
	LogicSoDAO logicSoDAO;
	
	@Resource(name = "logicSoItemDAO")
	LogicSoItemDAO logicSoItemDAO;
	
	@Resource(name = "logicWhAffStockService")
	private ILogicWhAffStockService logicWhAffStockService;
	
	@Resource(name = "syCodeService")
	private SyCodeService syCodeService;
	
	@Resource(name="logicSoWarefreezedealItemBatchDAO")
	private LogicSoWarefreezedealItemBatchDAO logicSoWarefreezedealItemBatchDAO;
	
	@Override
	public SearchResult findListByExample(SearchConditions scs)
			throws SyBaseException {
		SearchResult rs=new SearchResult(scs);
		List<LogicSoWarefreezedealDO> list=logicSoWarefreezedealDAO.find(scs);
		rs.setRecordCount(logicSoWarefreezedealDAO.count(scs));
		rs.setResults(list);
		return rs;
	}

	@Override
	public Integer delete(String id, User user) throws SyBaseException {
		return logicSoWarefreezedealDAO.deleteLogicSoWarefreezedealDOByPrimaryKey(id);
	}

	@Override
	@Transactional
	public Integer update(LogicSoWarefreezedealDO t, User user)
			throws SyBaseException {
		t.setDuuser(user.getName());
		t.setDutime(new Date());
		return logicSoWarefreezedealDAO.updateLogicSoWarefreezedealDO(t);
	}

	@Override
	@Transactional
	public LogicSoWarefreezedealDO save(LogicSoWarefreezedealDO t, User user)
			throws SyBaseException {
		t.setDcruser(user.getName());
		t.setDctime(new Date());
		logicSoWarefreezedealDAO.insertLogicSoWarefreezedealDO(t);
		return t;
	}

	@Override
	public LogicSoWarefreezedealDO findListById(String id) throws SyBaseException {
		return logicSoWarefreezedealDAO.findLogicSoWarefreezedealDOByPrimaryKey(id);
	}
	
	

	/**
	 * 单据的子项持久化
	 * @param soItemlist
	 * @param curAP
	 */
	private void saveOrUpdateItems(List<LogicSoWarefreezedealItemDO> soItemlist ,LogicSoWarefreezedealDO curAP){
		//删除本订单下的item
				if(null != curAP.getId()){
					List<LogicSoWarefreezedealItemDO> list = logicSoWarefreezedealItemDAO.findItemListByswfdId(curAP.getId());
					if(list != null &&  list.size() > 0){
						for (int i = 0; i < list.size(); i++) {
							logicSoWarefreezedealItemBatchDAO.deleteBywfdId(list.get(i).getId());
						}
					}
					logicSoWarefreezedealItemDAO.deleteLogicSoWarefreezedealItemDOBySoWareId(curAP.getId());
				}
				
				//插入单据的item
				if(null != soItemlist){
					for (LogicSoWarefreezedealItemDO soItemDO : soItemlist) {
						//对需要处理的item进行赋值
						String wfdid =IDCodeTypeUtil.getId();
						soItemDO.setId(wfdid);
						soItemDO.setWfdId(curAP.getId());
						soItemDO.setSoNo(curAP.getNo());
						soItemDO.setCliNo(curAP.getCliNo());
						soItemDO.setCliName(curAP.getCliName());
						
						
						logicSoWarefreezedealItemDAO.insertLogicSoWarefreezedealItemDO(soItemDO);
						if(soItemDO.getItemBatch() != null && !"".equals(soItemDO.getItemBatch().trim())){
							List<LogicSoWarefreezedealItemBatchDO> itemBatchDOs = JSONArray.parseArray(soItemDO.getItemBatch(),LogicSoWarefreezedealItemBatchDO.class);
							for (int i = 0; i < itemBatchDOs.size(); i++) {
								itemBatchDOs.get(i).setId(IDCodeTypeUtil.getId());
								itemBatchDOs.get(i).setWfdid(wfdid);
								logicSoWarefreezedealItemBatchDAO.insertLogicSoWarefreezedealItemBatchDO(itemBatchDOs.get(i));
							}
						}
					}
				}
	}
	

	@Override
	@Transactional
	public void sowfdSave(HttpServletRequest request, LogicSoWarefreezedealDO curAP)
			throws SyBaseException {
		try {
			String itemdata = request.getParameter("itemdata");
			List<LogicSoWarefreezedealItemDO> sowfdItemlist = JSONArray.parseArray(itemdata,
					LogicSoWarefreezedealItemDO.class);
			
			/*
			 * 获取操作
			 * 0为保存(草稿状态)
			 * 1为提交(待审核状态)
			 * 2为三级结案(提交三级结案)
			 * 3为二级驳回到草稿
			 * 4为拟稿人取消订单
			 */
			String paramflag = request.getParameter("paramflag");
			int iToFlag = -1;
			iToFlag = Integer.parseInt(paramflag);
			curAP.setBillstatus(Integer.parseInt(paramflag));
			
			User user = SessionUtil.getUser(request);
			Date curDate = new Date();
			
			
			if (StringUtils.isBlank(curAP.getId())) {
				/* 新增  设置状态billstatus= 0*/
				
				//---start 判断单据是否存在未完成处理的记录
				if(StringUtils.isBlank(curAP.getSowarefreezeNo())){
					throw new SyBaseException("销售申请单编号参数为空");
				}
				SearchConditions soScs = new SearchConditions();
				soScs.addCondition("sowarefreeze_no", curAP.getSowarefreezeNo(), SearchCondition.OP_EQUAL);
				soScs.addCondition("billstatus", "2", SearchCondition.OP_NOTEQUAL);
				soScs.addCondition("billstatus", "4", SearchCondition.OP_NOTEQUAL);
				Integer count = logicSoWarefreezedealDAO.count(soScs);
				if(null != count && count > 0){
					throw new SyBaseException(curAP.getSoNo()+"销售申请单存在未处理的销售冻结处理单");
				}
				//---end 判断单据是否存在未完成处理的记录
				
				String id = IDCodeTypeUtil.getId();
				curAP.setId(id);
				curAP.setDctime(curDate);
				curAP.setDcruser(user.getName());
				
				curAP.setLister(user.getName());
				curAP.setListerName(user.getRealName());
				curAP.setUnfrozenStatus(0);//未解冻
				
				curAP.setNo(syCodeService.getCode("SF","SF",SyCode.DATE_YYMM,5));
				
				//日期转换处理
//				String receipDate = request.getParameter("receipDate");
//				if(StringUtils.isNotBlank(receipDate)){
//					curAP.setReceipDate(DateUtils.stringToDate(receipDate));
//				}
				String deliveryDate = request.getParameter("deliveryDate");
				if(StringUtils.isNotBlank(deliveryDate)){
					curAP.setDeliveryDate(DateUtils.stringToDate(deliveryDate));
				}
				
				logicSoWarefreezedealDAO.insertLogicSoWarefreezedealDO(curAP);
				
				curAP.setId(id);//添加上，否则插入之后ID为0
				saveOrUpdateItems(sowfdItemlist, curAP);
				
				
			} else if(iToFlag >= 0 && iToFlag <=4){
				/* 修改 */
				LogicSoWarefreezedealDO bean=logicSoWarefreezedealDAO.findLogicSoWarefreezedealDOByPrimaryKey(curAP.getId());
				if(null == bean.getVersion() || !bean.getVersion().equals(curAP.getVersion())){
					throw new SyBaseException("版本号异常，请刷新后重新编辑");
				}
				
				bean.setBillstatus(iToFlag);
				
				int result = 0;
				if(1==iToFlag ){//2为二级审核(提交二级审核)
					curAP.setBillstatus(bean.getBillstatus());
					
					curAP.setDctime(bean.getDctime());
					curAP.setDcruser(bean.getDcruser());
					
					curAP.setLister(user.getName());
					curAP.setListerName(user.getRealName());
					curAP.setDutime(curDate);
					curAP.setDuuser(user.getName());
					
					//日期转换处理
//					String receipDate = request.getParameter("receipDate");
//					if(StringUtils.isNotBlank(receipDate)){
//						curAP.setReceipDate(DateUtils.stringToDate(receipDate));
//					}
					String deliveryDate = request.getParameter("deliveryDate");
					if(StringUtils.isNotBlank(deliveryDate)){
						curAP.setDeliveryDate(DateUtils.stringToDate(deliveryDate));
					}
					
					result =logicSoWarefreezedealDAO.updateLogicSoWarefreezedealDO(curAP);
					if(result==1){
						saveOrUpdateItems(sowfdItemlist, curAP);
					}
				}else if(2==iToFlag ){//2二级结案(提交二级结案)
					/*
					 * 【冻结处理】
					 * --因解冻和出库涉及冻结状态。出库、冻结、解冻需要同时考虑。解冻会影响冻结的状态，出库会影响冻结的状态。
					 * 结合订单、订单item、冻结申请单、冻结申请单item。
					 * 涉及字段：订单数量、累计已出库数量、总已冻结数量（可增减）、累计已冻结出库数量、当前单据已冻结数量，当前单据已解冻数量、可用库存数量
					 * @author huang.xuming[2013-08-14]
					 * =======================
					 * 
					 * 订单完全冻结标记=true；//出库、解冻时需要关联处理该字段
					 * 冻结申请单据完全冻结标记=true；//出库、解冻时需要关联处理该字段
					 * 
					 * 获取冻结申请单据(冻结申请的编码)；
					 * 获取冻结申请单据item(冻结申请的ID)；
					 * 
					 * 获取订单（订单编码）；
					 * 获取订单item（订单ID）；
					 * 
					 * for(订单item){
					 * 		订单当前item_剩余可冻结数量=订单当前item.订单数量-订单当前item.累计出库数量-订单当前item.总冻结数量
					 * 		for(冻结申请单item){
					 * 			冻结申请单当前item_剩余可冻结数量=
					 * 				MIN(订单当前item.剩余可冻结数量,(冻结申请单当前item.申请冻结数量-冻结申请单当前item.累计冻结数量))
					 * 			if(订单当前item.产品编码==冻结申请单item.产品编码){//理论上可能多个
					 * 				
					 * 				for(冻结处理单item){
					 * 					
					 * 					if(冻结处理单当前item.产品编码==冻结申请单item.产品编码){//理论上可能多个
					 * 						if(冻结处理单当前item.冻结数量>冻结申请单item_剩余可冻结数量
					 * 							 || 冻结处理单当前item.冻结数量 > 订单当前item_剩余可冻结数量){
					 * 							异常！
					 * 						}
					 * 
					 * 						if(冻结处理单当前item.冻结数量>当前物料可用库存数量){
					 * 							异常！
					 * 						}
					 * 							
					 * 						订单当前item.总冻结数量+=冻结处理单当前item.冻结数量；
					 * 						冻结申请单当前item.累计冻结数量+=冻结处理单当前item.冻结数量；
					 * 
					 * 						持久化冻结处理单当前item
					 * 						持久化冻结申请单当前item
					 * 						持久化冻订单当前item
					 * 						
					 * 						冻结库存处理
					 * 					}
					 * 
					 * 				}
					 * 			}
					 * 
					 * 			if(冻结申请单当前item.累计冻结数量 < 冻结申请单当前item.申请冻结数量){
					 * 				冻结申请单据完全冻结标记=false;
					 * 			}else if (冻结申请单当前item.累计冻结数量 > 冻结申请单当前item.申请冻结数量){
					 * 				异常！
					 * 			}	
					 * 		}
					 * 
					 * 		if(处理后的剩余可出库库存>0){
					 * 			订单完全冻结标记=false；
					 * 		}else if(处理后的剩余可出库库存<0){
					 * 			异常！
					 * 		}
					 * }
					 * 
					 * 持久化冻结处理单
					 * 持久化冻结申请单
					 * 持久化销售订单
					 * 
					 */
					
					boolean isSoFullFrozen = true;
					boolean isSwfFullFrozen = true;
					
					//冻结申请单bean
					SearchConditions scs1 = new SearchConditions();
					scs1.addCondition("no", curAP.getSowarefreezeNo(), SearchCondition.OP_EQUAL);
					List<LogicSoWarefreezeDO> sowfDOList= logicSoWarefreezeDAO.find(scs1);
					if(null == sowfDOList || 0 == sowfDOList.size() ){
						throw new SyBaseException(curAP.getSowarefreezeNo()+"冻结申请单号不存在");
					}
					LogicSoWarefreezeDO sowfDO = sowfDOList.get(0);
					//冻结申请单item
					List<LogicSoWarefreezeItemDO> sowfItemList= logicSoWarefreezeItemDAO.findItemListBySoWareFreezeId(sowfDO.getId());
					if(null == sowfItemList || 0 == sowfItemList.size() ){
						throw new SyBaseException(curAP.getSowarefreezeNo()+"冻结申请单号的item不存在");
					}
					
					//销售单bean
					SearchConditions scs2 = new SearchConditions();
					scs2.addCondition("no", curAP.getSoNo(), SearchCondition.OP_EQUAL);
					List<LogicSoDO> soDOList = logicSoDAO.find(scs2);
					if(null == soDOList || 0 == soDOList.size() ){
						throw new SyBaseException(curAP.getSowarefreezeNo()+"销售单号不存在");
					}
					LogicSoDO soDO = soDOList.get(0);
					//销售单item
					List<LogicSoItemDO> soItemList = logicSoItemDAO.findItemListBysoId(soDO.getId());
					if(null == soItemList || 0 == soItemList.size() ){
						throw new SyBaseException(curAP.getSowarefreezeNo()+"销售单号的item不存在");
					}
					
					for(LogicSoItemDO curSoItem : soItemList){
						//订单当前item_剩余可冻结数量=订单当前item.订单数量-订单当前item.累计出库数量-订单当前item.总冻结数量
						//剩余可冻结和出库数量的方法
//						double soItemCanFreezeBQty = LogicSoBeanUtil.getInstance().calcSoItemCanFreezeBQty(curSoItem);
						
						for(LogicSoWarefreezeItemDO curSowfItem : sowfItemList){
							//冻结申请单当前item_剩余可冻结数量=申请单数量-累计数量
//							double sowfItemCanFreeze = curSowfItem.getSqdjQuantity() - curSowfItem.getSjdjQuantity();
//							if(sowfItemCanFreeze > soItemCanFreeze){
//								sowfItemCanFreeze = soItemCanFreeze;
//								
//								logger.warn(sowfDO.getNo()+"冻结处理单的产品剩余可用冻结数量大于订单剩余可用冻结数量。系统已经处理-"+curSowfItem.getProdNo());
//							}
//							if(curSoItem.getProdNo().equals(curSowfItem.getProdNo())
//									&& curSoItem.getStatus().equals(curSowfItem.getStatus())){//编号、状态一致
							if(LogicSoBeanUtil.getInstance().isSameMaterial(curSoItem, curSowfItem)){//相同物料
								for(LogicSoWarefreezedealItemDO sowfdItem :  sowfdItemlist){
//									if(curSowfItem.getProdNo().equals(sowfdItem.getProdNo())
//											&& curSoItem.getStatus().equals(curSowfItem.getStatus())){//编号、状态一致
									if(LogicSoBeanUtil.getInstance().isSameMaterial(curSowfItem, sowfdItem)){
										
										double dcDjBQty = sowfdItem.getDjBQuantity();//当前冻结处理单实际冻结数量
										
										if(dcDjBQty < 0.0){
											throw new SyBaseException("冻结的基本单位数量需大于0。   "+dcDjBQty);
										}
										//冻结数量需小于冻结单可冻结数量、订单可冻结数量
										if(dcDjBQty > LogicSoBeanUtil.getInstance().calcFreezeItemCanFreezeBQty(curSowfItem) ||
												dcDjBQty > LogicSoBeanUtil.getInstance().calcSoItemCanFreezeBQty(curSoItem)){
											
											throw new SyBaseException(sowfDO.getNo()+"冻结处理单，的产品（"+curSowfItem.getProdNo()
													+"）冻结基本单位数量("+dcDjBQty+")大于可冻结("
													+LogicSoBeanUtil.getInstance().calcFreezeItemCanFreezeBQty(curSowfItem)+"|"+ LogicSoBeanUtil.getInstance().calcSoItemCanFreezeBQty(curSoItem)+")");
										}
										
										
										/* 冻结库存处理 */
										//减少可用库存，添加冻结库存
										sowfdItem.setProdPrice(curSoItem.getProdBUnitPriceWithTax());
										freezeWhAff(curAP, sowfdItem, SessionUtil.getUser(request));
										
										/* 订单、冻结申请单冻结数量计算 */
										//冻结申请单当前item.累计冻结数量
										curSowfItem.setSjdjBQuantity(curSowfItem.getSjdjBQuantity()+dcDjBQty);
										curSowfItem.setSjdjQuantity(
												MathUtil.mathUtil.divide(curSowfItem.getSjdjBQuantity(), curSowfItem.getProdUnitConvert()));
										//订单当前item.总冻结数量
										curSoItem.setFrozenBQuantity(curSoItem.getFrozenBQuantity()+dcDjBQty);
										curSoItem.setFrozenQuantity(
												MathUtil.mathUtil.divide(curSoItem.getFrozenBQuantity(), curSowfItem.getProdUnitConvert()));
										
										/*持久化订单当前item*/
										//回写订单必要的数据   总冻结数量
										logicSoItemDAO.updateLogicSoItemDO(curSoItem);
										/*持久化冻结处理单当前item */
										//回写订单必要的数据 最后一次是累计出库数量、总冻结数量、各处理单累计冻结数量
										curSowfItem.setCkQuantity(curSoItem.getCkQuantity());
										curSowfItem.setCkBQuantity(curSoItem.getCkBQuantity());
										curSowfItem.setFrozenQuantity(curSoItem.getFrozenQuantity());
										curSowfItem.setFrozenBQuantity(curSoItem.getFrozenBQuantity());
										logicSoWarefreezeItemDAO.updateLogicSoWarefreezeItemDO(curSowfItem);
										/*持久化冻结处理单当前item*/
										// 回写订单必要的数据 最后一次是累计出库数量、总冻结数量、当前冻结数量
										//XXX 本单据可考虑不回写
										sowfdItem.setCkQuantity(curSoItem.getCkQuantity());
										sowfdItem.setCkBQuantity(curSoItem.getCkBQuantity());
										sowfdItem.setFrozenQuantity(curSoItem.getFrozenQuantity());
										sowfdItem.setFrozenBQuantity(curSoItem.getFrozenBQuantity());
//										sowfdItem.setSjdjQuantity(sowfdItem.getSjdjQuantity()+dcDjQty);
//										sowfdItem.setSjdjBQuantity(
//												MathUtil.mathUtil.multiply(sowfdItem.getSjdjQuantity(), curSowfItem.getProdUnitConvert()));
										
										logicSoWarefreezedealItemDAO.updateLogicSoWarefreezedealItemDO(sowfdItem);
										
									}
								}
							}
						}
					}
					
					//冻结申请单的完全冻结标记处理
					for(LogicSoWarefreezeItemDO curSowfItem : sowfItemList){
						double freezeItemCanFreezeBQty2 = LogicSoBeanUtil.getInstance().calcFreezeItemCanFreezeBQty(curSowfItem);
						logger.debug("LogicSoWarefreezedealServiceImpl.sowfdSave()soItemCanFreezeBQty2:"+(0<freezeItemCanFreezeBQty2) +"  "+(0.0<freezeItemCanFreezeBQty2)+"  "+(freezeItemCanFreezeBQty2));
						if(freezeItemCanFreezeBQty2 > 0.0){
							isSwfFullFrozen = false;
						}else if(freezeItemCanFreezeBQty2 < 0.0){
							throw new SyBaseException(sowfDO.getNo()+"冻结申请单的item("+curSowfItem.getProdNo()+")剩余可用出库库存为负数");
						}
					}
					
					//销售订单的完全冻结标记处理
					for(LogicSoItemDO curSoItem : soItemList){
						double soItemCanFreezeBQty2 = LogicSoBeanUtil.getInstance().calcSoItemCanFreezeBQty(curSoItem);//冻结处理后的剩余可出库库存
						if(soItemCanFreezeBQty2 > 0.0 ){
							isSoFullFrozen = false;
						}else if(soItemCanFreezeBQty2 < 0.0 ){
							throw new SyBaseException(soDO.getNo()+"销售订单的item剩余可出库库存为负数-"+curSoItem.getProdNo());
						}
					}
					
					//订单完结，冻结申请单据也完结 -- //XXX 不足，只能指定到当前单据
					if(isSoFullFrozen == true){
						isSwfFullFrozen = true;
					}
					
					//持久化销售订单
					soDO.setFrozenStatus((true==isSoFullFrozen)?1:2);//冻结状态：全部冻结、部分冻结
					logicSoDAO.updateLogicSoDO(soDO);
					
					//持久化冻结申请单
					sowfDO.setFrozenStatus((true==isSwfFullFrozen)?1:2);//冻结状态：全部冻结、部分冻结
					logicSoWarefreezeDAO.updateLogicSoWarefreezeDO(sowfDO);
					
					//持久化冻结处理单
					bean.setAuditor(user.getName());
					bean.setAuditorName(user.getRealName());
					result =logicSoWarefreezedealDAO.updateLogicSoWarefreezedealDO(bean);
					
				}else if(3==iToFlag){//3为二级驳回到草稿
					bean.setAuditor(user.getName());//二级
					bean.setAuditorName(user.getRealName());
					result =logicSoWarefreezedealDAO.updateLogicSoWarefreezedealDO(bean);
				}else if(4==iToFlag){//4为取消订单 
					bean.setDutime(bean.getDctime());
					bean.setDuuser(bean.getDcruser());
					result =logicSoWarefreezedealDAO.updateLogicSoWarefreezedealDO(bean);
					
				}
				if(result==0){
					throw new SyBaseException("您修改的行数据发生改变，请重新点开查看");
				}
				
			}else{
				throw new SyBaseException("ParamFlag不合法："+iToFlag);
			}
			
		} catch (Exception e) {
			//e.printStackTrace();
			logger.error(e.getMessage(), e);
			throw new SyBaseException(GlobalResLoader.getOpfailed()
					+ e.getMessage());
		}
		
	}

	@Override
	public List<LogicSoWarefreezedealItemDO> findItemListBysowfdId(
			String sowfdId) {
		List<LogicSoWarefreezedealItemDO> list = logicSoWarefreezedealItemDAO.findItemListByswfdId(sowfdId);
        return list;
	}
	
//	/**
//	 * 实时计算订单的产品的可冻结当前单位数量
//	 * 订单当前item_剩余可冻结数量=订单当前item.订单数量-订单当前item.累计出库数量-订单当前item.总冻结数量
//	 * @param soItem
//	 * @return
//	 */
//	private double getSoItemCanFreezeQty(LogicSoItemDO soItem){
//		return soItem.getProdQuantity() - soItem.getCkQuantity() - soItem.getFrozenQuantity();
//	}
	
	/**
	 * 库存冻结--可用库存减少，冻结库存添加
	 * @param curAP
	 * @param sowfdItem
	 * @param user
	 * @param jquantity
	 */
	private void freezeWhAff(LogicSoWarefreezedealDO curAP,LogicSoWarefreezedealItemDO sowfdItem,User user) throws SyBaseException{
		
//		String prodBatch = sowfdItem.getProdBatch();
//		prodBatch = (null != prodBatch) ? prodBatch: "";
		
		//库存是否足够
//		boolean ifEnough = logicWhAffStockService
//				.validateStorageQuaitity(sowfdItem.getProdNo(), curAP.getWhcode(), sowfdItem.getHubcode(), sowfdItem.getStatus(), sowfdItem.getProdBatch(), jquantity);
//		if(!ifEnough){
//			throw new SyBaseException(sowfdItem.getProdNo()+"产品，库存不足"+jquantity);
//		}
		//huang.wei修改 2013-11-08
		if("Y".equals(sowfdItem.getOpenBatch())){
			if(sowfdItem.getItemBatch() != null && !"".equals(sowfdItem.getItemBatch().trim())){
				List<LogicSoWarefreezedealItemBatchDO> itemBatchDOs = JSONArray.parseArray(sowfdItem.getItemBatch(),LogicSoWarefreezedealItemBatchDO.class);
				for (int i = 0; i < itemBatchDOs.size(); i++) {
				LogicWhAffDO lwhaff = new LogicWhAffDO();
				lwhaff.setBillCode(curAP.getNo());
				lwhaff.setBillType("SF");// 设置为销售冻结处理编码的头字符，供报表使用
				lwhaff.setWhCode(curAP.getWhcode());
				lwhaff.setWhname(curAP.getWhname());
				lwhaff.setBatch(itemBatchDOs.get(i).getProdBatch());
				lwhaff.setUnit(sowfdItem.getProdUnit());
				lwhaff.setJunit(sowfdItem.getProdBUnit());
				if(null != sowfdItem.getProdPrice()){
					lwhaff.setPrice(Double.valueOf(sowfdItem.getProdPrice().toString()));// ?
				}
				lwhaff.setCode(sowfdItem.getProdNo());
				lwhaff.setName(sowfdItem.getProdName());
				lwhaff.setSpec(sowfdItem.getProdSpecDesc());
				lwhaff.setBrand(sowfdItem.getProdModel());
				lwhaff.setHubCode(sowfdItem.getHubcode());
				lwhaff.setHubName(sowfdItem.getHubname());
				lwhaff.setStatus(sowfdItem.getStatus());// 冻结仓库
				if(null != sowfdItem.getProdUnitConvert()){
					double quantity = MathUtil.mathUtil.multiply(sowfdItem.getProdUnitConvert(), itemBatchDOs.get(i).getDjBQuantity());
					lwhaff.setQuantity(-quantity );
				}
				
				lwhaff.setJquantity(-itemBatchDOs.get(i).getDjBQuantity());// 减少库存
				/*可用库存减少*/
				logicWhAffStockService.updateWhAffstockQuantity(lwhaff,user,false);
				
				
				/*冻结库存添加*/
				lwhaff.setStatus("4");// 冻结仓库
		//		lwhaff.setRemark(sowfdItem.getStatus());//
				if(null != sowfdItem.getProdUnitConvert()){
					double quantity = MathUtil.mathUtil.multiply(sowfdItem.getProdUnitConvert(), itemBatchDOs.get(i).getDjBQuantity());
					lwhaff.setQuantity(quantity);
				}
				
				lwhaff.setJquantity(itemBatchDOs.get(i).getDjBQuantity());// 添加库存
				logicWhAffStockService.updateWhAffstockQuantity(lwhaff,user,false);
				}
			}
		
		}else{
			LogicWhAffDO lwhaff = new LogicWhAffDO();
			lwhaff.setBillCode(curAP.getNo());
			lwhaff.setBillType("SF");// 设置为销售冻结处理编码的头字符，供报表使用
			lwhaff.setWhCode(curAP.getWhcode());
			lwhaff.setWhname(curAP.getWhname());
			lwhaff.setBatch("NoBatch");
			lwhaff.setUnit(sowfdItem.getProdUnit());
			lwhaff.setJunit(sowfdItem.getProdBUnit());
			if(null != sowfdItem.getProdPrice()){
				lwhaff.setPrice(Double.valueOf(sowfdItem.getProdPrice().toString()));// ?
			}
			lwhaff.setCode(sowfdItem.getProdNo());
			lwhaff.setName(sowfdItem.getProdName());
			lwhaff.setSpec(sowfdItem.getProdSpecDesc());
			lwhaff.setBrand(sowfdItem.getProdModel());
			lwhaff.setHubCode(sowfdItem.getHubcode());
			lwhaff.setHubName(sowfdItem.getHubname());
			lwhaff.setStatus(sowfdItem.getStatus());// 冻结仓库
			if(null != sowfdItem.getProdUnitConvert()){
				double quantity = MathUtil.mathUtil.multiply(sowfdItem.getProdUnitConvert(), sowfdItem.getDjBQuantity());
				lwhaff.setQuantity(-quantity );
			}
			
			lwhaff.setJquantity(-sowfdItem.getDjBQuantity());// 减少库存
			/*可用库存减少*/
			logicWhAffStockService.updateWhAffstockQuantity(lwhaff,user,false);
			
			
			/*冻结库存添加*/
			lwhaff.setStatus("4");// 冻结仓库
	//		lwhaff.setRemark(sowfdItem.getStatus());//
			if(null != sowfdItem.getProdUnitConvert()){
				double quantity = MathUtil.mathUtil.multiply(sowfdItem.getProdUnitConvert(), sowfdItem.getDjBQuantity());
				lwhaff.setQuantity(quantity);
			}
			
			lwhaff.setJquantity(sowfdItem.getDjBQuantity());// 添加库存
			logicWhAffStockService.updateWhAffstockQuantity(lwhaff,user,false);
		}
	}

	@Override
	public Integer deleteBizRemoved(String id) throws SyBaseException {
		// TODO Auto-generated method stub
		return null;
	}
}
